/*
 * Archivo.cpp
 *
 *  Created on: Sep 11, 2012
 *      Author: romina
 */

#include "ArchivosManager.h"

namespace archivos {

ArchivoBase::ArchivoBase(){
	this->path = "";
	this->filename = "";
	this->cursor = 0;
}

ArchivoBase::ArchivoBase(string path){
	this->path = path;

	size_t pos = this->path.find_last_of("\\");
	if(pos != std::string::npos)
		this->filename.assign(path.begin() + pos + 1, path.end());
	else
	    this->filename = path;

	this->cursor = 0;
}

string ArchivoBase::leer(int desde, int tamanio){
	archivo.seekg(desde, ios_base::beg);
	char * buffer = new char[tamanio];
	memset(buffer, 0, tamanio);
	archivo.read(buffer, tamanio);
	string buff=(string)buffer;
	return buff;
}

int ArchivoBase::tamanio(){
	long beg, end;
	archivo.seekg (0, ios::beg);
	beg = archivo.tellg();
	archivo.seekg (0, ios::end);
	end = archivo.tellg();
	archivo.close();
	return (end-beg);
}


bool ArchivoDeTexto::existe(string filename){
		ifstream file;
		file.open(filename.c_str(),fstream::in);
		if(!file.is_open()){
		   return false;
		}else{
		   file.close();
		   return true;
		}
}


//string ArchivoBase::getBloque(int numero){
//
//        int size = sizeof(unsigned int);
//
//        archivo.seekg(numero, ios_base::beg);
//        char * buffer = new char[size];
//        memset(buffer, 0, size);
//        archivo.read(buffer, size);
//        string buff=(string)buffer;
//
//        return buff;
//}


string ArchivoBase::getPath(){
	return this->path;
}

void ArchivoBase::set_ancho(int ancho){
	this->archivo.width(ancho);
}

ArchivoBase::~ArchivoBase(){
	archivo.close();
}


void ArchivoBase::ir_al_principio(){
	archivo.seekg(0, ios::beg);
}

int ArchivoBase::getchar(){
	int c = 0;
	archivo >> c;
	return c;
}

string ArchivoBase::obtenerLinea(){

	string line;

	getline(archivo, line);

	this->cursor = this->archivo.tellg();
	return line;
}

string ArchivoBase::obtenerLineaHastaBarra(){

	string line;

	getline(archivo, line, '|');

	this->cursor = this->archivo.tellg();

	return line;
}

string ArchivoBase::obtenerPalabra(){

	string s;

	this->archivo >> s;

	this->cursor = this->archivo.tellg();

	return s;
}

void ArchivoBase::escribirPalabra(string palabra){
	archivo << palabra;
}

void ArchivoBase::escribirLinea(string linea){
	archivo << linea << endl;
}

int ArchivoBase::get_cursor(){
	return this->cursor;
}



bool ArchivoBase::is_EOF(){
	return archivo.eof();
}

ArchivoDeTexto::ArchivoDeTexto(string path, MODOAPERTURA modo) : ArchivoBase(path){

	switch (modo) {
		case R:
			archivo.open(path.c_str(), std::fstream::in);
			break;
		case W:
			archivo.open(path.c_str(), std::fstream::out);
			break;
		case RW:
			archivo.open(path.c_str(), std::fstream::in | std::fstream::out);
			break;
		default:
			throw (FaltaElModoDeAperturaException());
			break;
	}
	if (!archivo.is_open()){
		throw std::ios_base::failure("Error al intentar abrir / crear el archivo");
	}
}

ArchivoDeTexto::~ArchivoDeTexto(){
	archivo.close();
}


ArchivoBinario::ArchivoBinario() : ArchivoBase(){

}

ArchivoBinario::ArchivoBinario(string path, MODOAPERTURA modo) : ArchivoBase(path){

	switch (modo) {
		case R:
			archivo.open(path.c_str(), std::fstream::in | std::fstream::binary);
			break;
		case W:
			archivo.open(path.c_str(), std::fstream::out | std::fstream::binary);
			break;
		case RW:
			archivo.open(path.c_str(), std::fstream::in | std::fstream::out | std::fstream::binary);
			break;
		default:
			throw (FaltaElModoDeAperturaException());
			break;
	}
//	if (!archivo.is_open()){
//		//throw std::ios_base::failure("Error al intentar abrir / crear el archivo");
//		archivo.open(path.c_str(), std::fstream::out | std::fstream::binary);
//		archivo.close();
//	}
}









void ArchivoBinario::crear(string filename){
	fstream file;
	file.open(filename.c_str(), fstream::out | fstream::binary);
	file.close();
}


bool ArchivoBinario::existe(string filename){

	fstream file;
	file.open(filename.c_str(), fstream::in | fstream::out | fstream::binary);
	if (file.is_open()) {
		file.close();
	    return true;
	}
	return false;
}

long ArchivoBinario::get_tamanio(string filename){
	ifstream file(filename.c_str(),ios::in|ios::binary);
	long beg, end;
	beg = file.tellg();
	file.seekg (0, ios::end);
	end = file.tellg();
	file.close();
	return (end-beg);
}

string ArchivoBinario::read(string filename, int posicion_inicio, int size){

	ifstream file(filename.c_str(),ios::in|ios::binary);
    file.seekg(posicion_inicio, ios_base::beg);
    char * buffer = new char[size];
    memset(buffer, 0, size);
    file.read(buffer, size);
    string buff=(string)buffer;
    file.close();
    return buff;

}

void ArchivoBinario::writecur(string filename, string data){
	ofstream file(filename.c_str(),ios::out|ios::binary);
	file.write(data.c_str(),data.length());
	file.close();
}

void ArchivoBinario::writeapp(string filename, string data){
    ofstream file(filename.c_str(),ios::out|ios::binary|ios::app);
    file.write(data.c_str(),data.length());
    file.close();
}

void ArchivoBinario::writepos(string filename, int pos, string data){
    ofstream file(filename.c_str(),ios::out|ios::binary);
    file.seekp(pos, ofstream::cur);
    file.write(data.c_str(),data.length());
    file.close();
}



ArchivoBinario::~ArchivoBinario(){
	archivo.close();
}

} /* namespace archivo */
